/**
 * 类
 */
class Person{
    //普通的成员变量 -- 都是属于对象的 -- 用对象调用
    //字段-》属性-》成员变量
    public String name;
    public int age;
    public static int con = 10;

    /*//静态成员变量 -- 类变量 -- 属于类 -- 用类调用
    public static int count; //静态变量只能在类中定义

    //普通成员方法-》行为 -- 依赖对象，只能用对象调用
    public void eat(){
        System.out.println(name+"正在吃饭");
//        static int size;  普通方法里边不能定义静态变量：因为静态变量属于类，而这只是一个普通方法。定义在普通方法的属于方法的变量
        staticFunc(); //普通方法可以调用静态方法，静态方法属于类，权限大，可以直接通过类调用。
    }
    public void sleep(){
        System.out.println(name+"正在睡觉");
    }

    //静态方法 -- 不依赖对象，用类调用 -- 静态方法只能调用静态方法
    public static void staticFunc(){
        System.out.println("static:func");
        count = 10; //可以给静态变量赋值，但是不能定义
//        eat(); 静态方法里边不能调用普通方法：因为静态方法不依赖对象，直接用类调用，如果调用普通方法，需要用对象调用。
    }

    @Override //重写
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }*/

    //私有变量 -- 封装起来
    /*private String sex;
    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex; //this表示当前对象的引用
    }*/

    //构造方法 -- 用来构造对象
    /*public Person(){
        this("女"); //，表示调用带有一个参数的构造方法--必须放在第一行
        System.out.println("Person():不带参数的构造方法");
    }
    public Person(String sex){
        this.sex = sex;
        System.out.println(sex+" -- Person(String sex):带一个参数的构造方法");
    }
    public Person(String name, int age){
        System.out.println("Person(String name, int age):带2个参数的构造方法");
    }*/

    //实例代码块
    {
        con = 100;
        System.out.println("实例代码块");
    }
    //静态代码块:不实例化对象也会执行，并且从始至终只会执行一次 -- 静态代码块会先执行
    static {
        System.out.println("静态代码块");
    }
}
public class TestDemo {

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println(Person.con);  //如果定义了两次静态变量，则会打印最后定义的。（跟定义的顺序有关）
        System.out.println("===========");
        Person person2 = new Person();

        /*Person person = new Person();
        Person person1 = new Person("nv");
        Person person2 = new Person("sy",20);*/
    }

 /*   public static void main2(String[] args) {
//        Person person = null; //这个引用不指向任何的对象
        Person person = new Person();
        Person person1 = new Person();
        Person person2 = person1; //person2这个引用指向person1这个引用所指向的对象

        person.name = "sy";
        person.age = 20;
        System.out.println(person); //打印这个对象，会调用toString()

        person.setSex("nv");
        System.out.println(person.getSex());
    }*/

   /* public static void main1(String[] args) {
        Person person = new Person(); //实例化对象
        person.name = "bit";
        person.age = 20;

        Person person1 = new Person();
        person1.name = "sy";
        System.out.println(person1.name);

        System.out.println(person.name); //成员变量的访问是通过引用来访问
        System.out.println(person.age);
        person.eat();
        person.sleep();

        Person.count = 1999;    //静态成员变量用类名直接调用
//        System.out.println(person.count);
        Person.count++;
        System.out.println(Person.count);
        Person.staticFunc(); //静态方法直接用类调用，不用创建对象
    }*/
}


